Tensorarray
=================

张量数组操作，支持从张量数组中读取指定索引的张量，或将张量写入到张量数组的指定索引位置。该算子不区分数据类型，适用于所有数据类型。

**TensorArrayRead（读取操作）：**

从张量数组中读取指定索引的张量，并将其数据复制到输出。

.. math::

    \text{output} = \text{tensors}[\text{index}]

**TensorArrayWrite（写入操作）：**

将输入张量的数据复制到张量数组的指定索引位置。

.. math::

    \text{tensors}[\text{index}] = \text{input}

两个操作都会复制数据，复制大小为 `size * type_size` 字节。

输入（TensorArrayRead）：
    - **tensors** - 张量数组（Tensor** 类型），包含多个张量。
    - **index** - 读取的索引（int 类型），指定从 `tensors` 数组中读取哪个张量。
    - **core_mask** - 核掩码（int），仅共享存储版本需要。

输出（TensorArrayRead）：
    - **output** - 输出张量（Tensor* 类型），包含复制后的数据。输出张量的 `size` 和 `type_size` 应与选中的输入张量相同。

输入（TensorArrayWrite）：
    - **input** - 输入张量（Tensor* 类型），待写入的数据。
    - **index** - 写入的索引（int 类型），指定写入到 `tensors` 数组的哪个位置。
    - **tensors** - 张量数组（Tensor** 类型），目标数组。
    - **core_mask** - 核掩码（int），仅共享存储版本需要。

输出（TensorArrayWrite）：
    - **tensors[index]** - 张量数组指定位置的数据会被更新。

支持平台：
    ``FT78NE``
    ``MT7004``

.. note::
    - 该算子不区分数据类型，适用于所有数据类型
    - 算子会复制数据，输入和输出张量数据独立
    - 调用前需要确保目标内存空间足够大（至少 `size * type_size` 字节）
    - 读取和写入时，涉及的张量的 `size` 和 `type_size` 应匹配

**共享存储版本:**

**TensorArrayRead（读取操作）:**

.. c:function:: void tensorarrayread_s(Tensor** tensors, int index, Tensor* output, int core_mask)

**TensorArrayWrite（写入操作）:**

.. c:function:: void tensorarraywrite_s(Tensor* input, int index, Tensor** tensors, int core_mask)

**C调用示例（TensorArrayRead）：**

.. code-block:: c
    :linenos:
    :emphasize-lines: 34

    //FT78NE示例
    #include <stdio.h>
    #include <tensorarray.h>

    int main(int argc, char* argv[]) {
        // 假设在DDR空间
        Tensor tensor0, tensor1, tensor2;
        Tensor output;
        
        // 初始化张量数组中的张量
        tensor0.type_size = 4;  // float32
        tensor0.size = 1000;
        tensor0.data = (void *)0xA0000000;
        
        tensor1.type_size = 4;
        tensor1.size = 1000;
        tensor1.data = (void *)0xA1000000;
        
        tensor2.type_size = 4;
        tensor2.size = 1000;
        tensor2.data = (void *)0xA2000000;
        
        // 初始化输出张量
        output.type_size = 4;
        output.size = 1000;
        output.data = (void *)0xB0000000;  // 需要预先分配足够的内存
        
        // 创建张量数组
        Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
        
        int index = 1;  // 读取 tensor1
        int core_mask = 0xff;
        
        tensorarrayread_s(tensors, index, &output, core_mask);
        
        // 此时 output.data 包含 tensor1.data 的副本
        
        return 0;
    }

**C调用示例（TensorArrayWrite）：**

.. code-block:: c
    :linenos:
    :emphasize-lines: 30

    //FT78NE示例
    #include <stdio.h>
    #include <tensorarray.h>

    int main(int argc, char* argv[]) {
        // 假设在DDR空间
        Tensor input;
        Tensor tensor0, tensor1, tensor2;
        
        // 初始化输入张量
        input.type_size = 4;  // float32
        input.size = 1000;
        input.data = (void *)0xA0000000;
        
        // 初始化张量数组中的张量（需要预先分配内存）
        tensor0.type_size = 4;
        tensor0.size = 1000;
        tensor0.data = (void *)0xB0000000;
        
        tensor1.type_size = 4;
        tensor1.size = 1000;
        tensor1.data = (void *)0xB0100000;
        
        tensor2.type_size = 4;
        tensor2.size = 1000;
        tensor2.data = (void *)0xB0200000;
        
        // 创建张量数组
        Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
        
        int index = 1;  // 写入到 tensor1 的位置
        int core_mask = 0xff;
        
        tensorarraywrite_s(&input, index, tensors, core_mask);
        
        // 此时 tensors[1]->data 包含 input.data 的副本
        
        return 0;
    }

**私有存储版本:**

**TensorArrayRead（读取操作）:**

.. c:function:: void tensorarrayread_p(Tensor** tensors, int index, Tensor* output)

**TensorArrayWrite（写入操作）:**

.. c:function:: void tensorarraywrite_p(Tensor* input, int index, Tensor** tensors)

**C调用示例（私有存储版本）：**

.. code-block:: c
    :linenos:
    :emphasize-lines: 14

    //FT78NE示例
    #include <stdio.h>
    #include <tensorarray.h>

    int main(int argc, char* argv[]) {
        // 假设在L2空间
        Tensor tensor0, tensor1, tensor2;
        Tensor output;
        
        tensor0.type_size = 4;  // float32
        tensor0.size = 1000;
        tensor0.data = (void *)0x10000000;
        
        tensor1.type_size = 4;
        tensor1.size = 1000;
        tensor1.data = (void *)0x10001000;
        
        tensor2.type_size = 4;
        tensor2.size = 1000;
        tensor2.data = (void *)0x10002000;
        
        output.type_size = 4;
        output.size = 1000;
        output.data = (void *)0x10003000;  // 需要预先分配足够的内存
        
        Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
        
        int index = 0;  // 读取 tensor0
        
        tensorarrayread_p(tensors, index, &output);
        
        return 0;
    }